package com.radar.io.radar346.DataType;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.amazonaws.util.IOUtils;
import com.github.misterchangray.core.MagicByte;
import com.radar.common.ProductType;
import com.radar.io.radar346.Product382改;
import com.radar.utils.BitConverter;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.python.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;

import java.io.*;
import java.nio.ByteBuffer;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Data
@Setter
@Getter
public class STIParser {
    public static  DecimalFormat df = new DecimalFormat("00");
    public  Date gcTime ;
    public  float  stormNum ;
    public static int storm_num ;

    List<STI> list  =new ArrayList<>();



    Product382改 _this;


    public STIParser(Product382改 product382改) {
        _this = product382改;
    }



    public  ProductType parse(byte[] bytes, int index , Product382改.RealFile header) {

        int Layers = header.realObserSec.iLiTiSaoMiaoCengShu;
        int[] Records = new int[Layers];
        double[] MaxV = new double[Layers];
        int Bins = 0;
        for (int i = 0; i < Layers; i++) {
            Records[i] = header.realObserSec.LayerParam[i].iCaiYangJinXiangShu;
            Bins = header.realObserSec.LayerParam[i].usRefBinNumber;
        }
        _this.azi = new double[Records[0]];  //长度为每层径向数
        byte[]bodyBytes = new byte[bytes.length-index];
        for (int i = index; i < bytes.length; i++) {
            bodyBytes[i-index]=bytes[i];
        }

//        STItst headdataByte = MagicByte.pack(bodyBytes, STItst.class);
        int i = BitConverter.toInt32(bytes, index);
        String ss = df.format(i);
        index += 4;  //s
        int i1 = BitConverter.toInt32(bytes, index);
        String mm = df.format(i1);
        index += 4;  //m
        int i2 = BitConverter.toInt32(bytes, index);
        String HH = df.format(i2);
        index += 4;  //h
        int i3 = BitConverter.toInt32(bytes, index);
        String dd = df.format(i3);
        index += 4;  //D  tian
        int i4 = BitConverter.toInt32(bytes, index);
        String MM = df.format(i4);
        index += 4;    //  月
        String yyyy = BitConverter.toInt32(bytes, index) + "";
        DateTime yyyyMMddHHmmss = DateUtil.parse(yyyy + MM + dd + HH + mm + ss, "yyyyMMddHHmmss");
        setGcTime(yyyyMMddHHmmss);
        index += 4;

        int i5 = BitConverter.toInt32(bytes, index);
        String tm_wday = df.format(i4);
        index += 4;    // tm_wday

        int i6 = BitConverter.toInt32(bytes, index);
        String tm_yday = df.format(i4);
        index += 4;    // tm_yday

        int i7 = BitConverter.toInt32(bytes, index);
        String tm_isdst = df.format(i4);
        index += 4;    // tm_isdst

        int storm = BitConverter.toInt32(bytes, index);   //第二个数据   //包含的 Storm 的个数
        setStormNum(storm); //风暴数量
        index+=4 ;
        for (int j = 0; j <storm  ; j++) {
            STI sti = new STI();
            long 所属风暴体的序号 =BitConverter.toInt32(bytes, index); // 所属风暴体的序号
            sti.set所属风暴体的序号(所属风暴体的序号);
            index+=4 ;
            long 属体扫的序号 = BitConverter.toInt32(bytes, index);  //所属体扫的序号
            sti.set所属体扫的序号(属体扫的序号);
            index+=4 ;
            byte[] xx = getXx(bytes, 1, index);//是否新的风暴体
            index+=1 ;
            //todo 风暴体特征描述数据结构
            long 据偏移 = BitConverter.toInt32(bytes, index);
            sti.set对应风暴组件数据偏移(据偏移);
            index+=4 ;
            long 风暴分量个数 = BitConverter.toInt32(bytes, index);
            sti.set风暴分量个数(风暴分量个数);
            index+=4 ;
            long  风暴体序列号 =  BitConverter.toInt16(bytes, index);  //风暴体序列号
            sti.set风暴体序列号(风暴体序列号);
            index+=2 ;
            float  最低仰角 =BitConverter.toFloat(bytes, index);  // 风暴体对应的最低仰角，度
            sti.set最低仰角(最低仰角);
            index+=4 ;
            float  最高仰角 =BitConverter.toFloat(bytes, index);  // 风暴体对应的最高仰角，度
            sti.set最高仰角(最高仰角);
            index+=4 ;
            float  顶高 =BitConverter.toFloat(bytes, index);  // 风暴体的顶高,km
            sti.set顶高(顶高);
            index+=4 ;
            float  底高 =BitConverter.toFloat(bytes, index);  // 风暴体的底高,km
            sti.set底高(底高);
            index+=4 ;
            float  权重中心所在的高度 =BitConverter.toFloat(bytes, index);  // 风暴体质量权重中心所在的高度,km
            sti.set权重中心所在的高度(权重中心所在的高度);
            index+=4 ;
            float  权重中心所在的距离 =BitConverter.toFloat(bytes, index);  //风暴体质量权重中心所在的距离,km
            sti.set权重中心所在的距离(权重中心所在的距离);
            index+=4 ;
            float  权重中心所在的方位 =BitConverter.toFloat(bytes, index);  //风暴体质量权重中心方位角
            sti.set权重中心所在的方位(权重中心所在的方位);
            index+=4 ;
            float  x轴 =BitConverter.toFloat(bytes, index);  //风暴体质量权重中心x轴
            sti.setX轴(x轴);
            index+=4 ;
            float  y轴 =BitConverter.toFloat(bytes, index);  //风暴体质量权重中心Y轴
            sti.setY轴(y轴);
            index+=4 ;
            float  权重体积 =BitConverter.toFloat(bytes, index);  //风暴体质量权重体积
            sti.set权重体积(权重体积);
            index+=4 ;
            float  含水量 =BitConverter.toFloat(bytes, index);  //风暴体对应的垂直累积液态含水量
            sti.set含水量(含水量);
            index+=4 ;
            float  最大反射率 =BitConverter.toFloat(bytes, index);  //最大反射率
            sti.set最大反射率(最大反射率);
            index+=4 ;
            float  最大反射率对应的高度 =BitConverter.toFloat(bytes, index);  //最大反射率对应的高度
            sti.set最大反射率对应的高度(最大反射率对应的高度);
            index+=4 ;
            float  风暴体的移速 =BitConverter.toFloat(bytes, index);  //风暴体的移速,m/s
            sti.set风暴体的移速(风暴体的移速);
            index+=4 ;
            float  风暴体的移向 =BitConverter.toFloat(bytes, index);  //风暴体的移向,度
            sti.set风暴体的移向(风暴体的移向);
            index+=4 ;
            float  前一次体扫时风暴体的中心方位 =BitConverter.toFloat(bytes, index);  //前一次体扫时风暴体的中心方位，度
            sti.set前一次体扫时风暴体的中心方位(前一次体扫时风暴体的中心方位);

            index+=4 ;
            float  前一次体扫时风暴体的中心距离 =BitConverter.toFloat(bytes, index);  //前一次体扫时风暴体的中心距离，km
            sti.set前一次体扫时风暴体的中心距离(前一次体扫时风暴体的中心距离);
            index+=4 ;
            float  备份1 =BitConverter.toFloat(bytes, index);  //前一次体扫时风暴体的中心距离，km
            sti.set备份1(备份1);
            index+=4 ;  //
            float  备份2 =BitConverter.toFloat(bytes, index);  //前一次体扫时风暴体的中心距离，km
            sti.set备份2(备份2);
            index+=4 ;
            int  前一个体扫风暴中的序号 = BitConverter.toInt32(bytes, index); //与前一个体扫匹配的风暴体在前一个体扫风暴中的序号
            sti.set前一个体扫风暴中的序号(前一个体扫风暴中的序号);
            index+=4 ;
            float  风暴现在的中心方位 =BitConverter.toFloat(bytes, index); //风暴现在的中心方位，度
            sti.set风暴现在的中心方位(风暴现在的中心方位);
            index+=4 ;
            float  风暴现在的中心距离 =BitConverter.toFloat(bytes, index); //风暴现在的中心距离，km
            sti.set风暴现在的中心距离(风暴现在的中心距离);
            index+=4 ;
            int  当前体扫风暴中的序号 =BitConverter.toInt32(bytes, index); //当前体扫时匹配的风暴体在当前体扫风暴中的序号    //31的数据
            sti.set当前体扫风暴中的序号(当前体扫风暴中的序号);
            index+=4 ;
            float  风暴现在的中心方位1 =BitConverter.toFloat(bytes, index); //前体 风暴现在的中心方位，度
            sti.set风暴现在的中心方位1(风暴现在的中心方位1);
            index+=4 ;
            float  风暴现在的中心距离1 =BitConverter.toFloat(bytes, index); //前体 风暴现在的中心距离，km
            sti.set风暴现在的中心距离1(风暴现在的中心距离1);
            index+=4 ;
            int  预测的数据个数 =BitConverter.toInt32(bytes, index); //预测的数据个数
            sti.set预测的数据个数(预测的数据个数);
            index+=4 ;
            int ii = BitConverter.toInt32(bytes, index);
            String ss1 = df.format(ii);
            index+= 4 ;  //s
            int ii1 = BitConverter.toInt32(bytes, index);
            String mm1 = df.format(ii1);
            index+= 4 ;  //m
            int ii2 = BitConverter.toInt32(bytes, index);
            String HH1 = df.format(ii2);
            index+= 4 ;  //h
            int ii3 = BitConverter.toInt32(bytes, index);
            String dd1 = df.format(ii3);
            index+= 4 ;  //D  tian
            int ii4 = BitConverter.toInt32(bytes, index);
            String MM1 = df.format(ii4);
            index+= 4 ;    //  月
            String yyyy1= BitConverter.toInt32(bytes, index)+"";
            DateTime yyyyMMddHHmmss1 = DateUtil.parse(yyyy1 + MM1 + dd1 + HH1 + mm1 + ss1, "yyyyMMddHHmmss");
            sti.set观测时间(yyyyMMddHHmmss1);
            index+= 4 ;

            index+= 4 ;
            index+= 4 ;
            index+= 4 ;
            testOut(bytes,index);
            list.add(sti);
        }

        return null;
    }


    public static void testOut(byte[] bytes, int index){
        byte[] bytes2 = new byte[bytes.length-index];
        int flag =0;
        for (int i = index; i < bytes.length; i++) {
            bytes2[flag]=bytes[flag];
            flag++;
            System.out.print(bytes[i]+",");
        }
        System.out.println();
    }

    public static float readFloat(byte[] bytes, int index) {
        if (bytes.length - index < 4) {
            throw new IllegalArgumentException(
                    "The length of the byte array must be at least 4 bytes for float.");
        }

        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 4);
        return buffer.getFloat();
    }

    public static long readUnsignedInt(byte[] bytes, int index) {
        if (bytes.length - index < 4) {
            throw new IllegalArgumentException(
                    "The length of the byte array must be at least 4 bytes for unsigned int.");
        }

        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 4);
        return buffer.getInt() & 0xFFFFFFFFL;
    }


    public static long readTm(byte[] bytes, int index) {
        ByteBuffer buffer = ByteBuffer.wrap(bytes, index, 18);
        return buffer.getLong();
    }


    /**
     *
     打开bz2文件
     */
    public static BZip2CompressorInputStream openBz2File(String filePath) throws IOException {
        FileInputStream fileInputStream = new FileInputStream(filePath);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BZip2CompressorInputStream bz2InputStream = new BZip2CompressorInputStream(bufferedInputStream);
        return bz2InputStream;
    }




    public static byte[] parseBz2File(String filePath) throws IOException {
        FileInputStream fis = new FileInputStream(filePath);
        BZip2CompressorInputStream bz2InputStream = new BZip2CompressorInputStream(fis);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = bz2InputStream.read(buffer)) != -1) {
            byteArrayOutputStream.write(buffer, 0, bytesRead);
        }
        bz2InputStream.close();
        fis.close();
        return byteArrayOutputStream.toByteArray();
    }




    /**
     *解压
     */
    public static void extractFile(BZip2CompressorInputStream bz2InputStream, String outputPath) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(outputPath);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        IOUtils.copy(bz2InputStream, bufferedOutputStream);
        bufferedOutputStream.close();
    }

    /**
     * 关闭
     */
    public static void closeBz2File(BZip2CompressorInputStream bz2InputStream) throws IOException {
        bz2InputStream.close();
    }


    public static void main(String[] args) throws IOException {
        int index = 0 ;
        byte[] bytes = parseBz2File("J:\\LEIDA\\202311\\20231111\\STIParser\\20231111_135806.00.049.005.0.bz2");
        byte[] tou = getXx(bytes, 2, index);
        short shortValue = (short) (tou[0] << 8 | tou[1]);
        index+=2 ;
        byte[] gm = getXx(bytes, 20, index);
        String s = new String(gm,"GBK");
        System.out.println(s);
        index = 1266 ;
        byte[] tm = getXx(bytes, 18, index);
        String s1 = new String(tm ,"UTF-8");
        System.out.println(s1);




    }
    public static byte[]  getXx(byte[] bytes, int read, int start){
        // 分离时间字段
        byte[] readByte = new byte[read];
        System.arraycopy(bytes, start, readByte, 0, read);
        return  readByte ;
    }



}
